/* eslint-disable no-extend-native */

/**
 * 数组是否存在
 */

Array.prototype.contains = function (obj) {
  var i = this.length
  while (i--) {
    if (this[i] === obj) {
      return true
    }
  }
  return false
}
/**
 * 数组中最大值 最小值
 * @param array
 * @returns
 */
Array.prototype.max = function () {
  return Math.max.apply({}, this)
}
Array.prototype.min = function () {
  return Math.min.apply({}, this)
}

const EchartFormate = {
  GroupFormate: (data, type) => {
    // 用于存储类型名称
    const groups = []
    // 用于存储data.name数据
    const names = []
    // 存储返回series数据 （一个或者多个）
    const series = []

    for (let i = 0; i < data.length; i++) {
      // 判断data[i].group是否存在数租groups中
      if (!groups.contains(data[i].group)) {
        // 不存在则跳进 存放
        groups.push(data[i].group)
      }
      // 判断name数据是否存在 数组names中
      if (!names.contains(data[i].name)) {
        // 不存在则跳进 存放
        names.push(data[i].name)
      }
    }

    // 遍历分类
    for (let i = 0; i < groups.length; i++) {
      // 定义一个series中间变量
      let tempSeries = {}
      // 定义data.value数据存储
      let tempData = []
      // 遍历所有数据
      for (let j = 0; j < data.length; j++) {
        // 遍历data.name数据
        for (let k = 0; k < names.length; k++) {
          // 判断所有分类中的所有数据含name数据分开
          if (groups[i] === data[j].group && names[k] === data[j].name) {
            tempData.push(data[j].value)
          }
        }
      }
      tempSeries = {
        name: groups[i],
        type: type,
        data: tempData,
        animationDuration: 2600
      }
      series.push(tempSeries)
    }
    return {groups: groups, category: names, series: series}
  },
  NoGroupFormate: (data) => {
    // category 的数据存储
    const categorys = []
    // data 的数据存储
    const datas = []
    // b遍历
    for (let i = 0; i < data.length; i++) {
      categorys.push(data[i].name || '')
      // 定义一个中间变量
      const tempData = {value: data[i].value || 0, name: data[i].name || ''}
      datas.push(tempData)
    }
    return {categorys: categorys, data: datas}
  },
  RadarFormate: (data, type) => {
    // 用于存储类型名称
    const groups = []
    // 用于存储data.name数据
    const names = []
    // 存储最大值数组
    const indicators = []
    // 定义data.value数据存储
    const tempData = []
    for (let i = 0; i < data.length; i++) {
      // 判断data[i].group是否存在数租groups中
      if (!groups.contains(data[i].group)) {
        // 不存在则跳进 存放
        groups.push(data[i].group)
      }

      // 判断name数据是否存在 数组names中
      if (!names.contains(data[i].name)) {
        // 不存在则跳进 存放
        names.push(data[i].name)
      }
    }

    for (let i = 0; i < names.length; i++) {
      // 中
      const tempMaxValue = []
      for (let j = 0; j < data.length; j++) {
        if (names[i] === data[j].name) {
          tempMaxValue.push(data[j].value)
        }
      }
      indicators.push({name: names[i], max: Number(tempMaxValue.max() * 2 / 1.5).toFixed(2)})
    }
    // 遍历分类
    for (let i = 0; i < groups.length; i++) {
      // 定义datavalue数组
      const dataValues = []
      // 遍历所有数据
      for (let j = 0; j < data.length; j++) {
        if (groups[i] === data[j].group) {
          dataValues.push(data[j].value)
        }
      }
      tempData.push({value: dataValues, name: groups[i]})
    }
   const series = {type: type, data: tempData, animationDuration: 2600}
    return {indicators: indicators, groups: groups, category: names, series: series}
  }
}
export {
  EchartFormate
}
